home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / machserver / 1.098 / proc / procRemote.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-26  |  35.2 KB  |  1,213 lines
  1. /* 
  2.  * procRemote.c --
  3.  *
  4.  *    Routines for a remote workstation to handle process migration.  This
  5.  *    involves the following:
  6.  *
  7.  *        - Grant permission to another workstation to migrate to this
  8.  *          one.
  9.  *        - Accept the process from the other workstation, creating a
  10.  *          local copy of it.
  11.  *        - Execute the process, sending system calls back to the home
  12.  *          node for processing.
  13.  *        - Transfer the process back to the home node upon termination.
  14.  *
  15.  * Copyright 1986, 1988 Regents of the University of California
  16.  * Permission to use, copy, modify, and distribute this
  17.  * software and its documentation for any purpose and without
  18.  * fee is hereby granted, provided that the above copyright
  19.  * notice appear in all copies.  The University of California
  20.  * makes no representations about the suitability of this
  21.  * software for any purpose.  It is provided "as is" without
  22.  * express or implied warranty.
  23.  */
  24.  
  25. #ifndef lint
  26. static char rcsid[] = "$Header: /sprite/src/kernel/proc/RCS/procRemote.c,v 9.15 91/07/26 16:59:56 shirriff Exp $ SPRITE (Berkeley)";
  27. #endif /* not lint */
  28.  
  29.  
  30. #include <sprite.h>
  31. #include <mach.h>
  32. #include <proc.h>
  33. #include <sync.h>
  34. #include <sched.h>
  35. #include <procMigrate.h>
  36. #include <procInt.h>
  37. #include <migrate.h>
  38. #include <fs.h>
  39. #include <stdlib.h>
  40. #include <string.h>
  41. #include <sig.h>
  42. #include <spriteTime.h>
  43. #include <list.h>
  44. #include <byte.h>
  45. #include <vm.h>
  46. #include <sys.h>
  47. #include <rpc.h>
  48. #include <sysSysCall.h>
  49. #include <sysSysCallParam.h>
  50. #include <dbg.h>
  51. #include <stdio.h>
  52. #include <procUnixStubs.h>
  53. #include <bstring.h>
  54. #include <recov.h>
  55.  
  56. extern int debugProcStubs;
  57.  
  58.  
  59. /*
  60.  * An address for copy-out or make accessible is reasonable if it is not NIL.
  61.  */
  62.  
  63. #define ValidAddress(addr) (((Address) addr != (Address) NIL) && \
  64.                 ((Address) addr != (Address) USER_NIL))
  65.  
  66.     
  67.  
  68. /*
  69.  *----------------------------------------------------------------------
  70.  *
  71.  * ProcMigAcceptMigration --
  72.  *
  73.  *    Handle a request to start process migration.
  74.  *    This could check things like the number of remote processes,
  75.  *    load, or whatever. For now, just check against a global flag
  76.  *    that says whether to refuse migrations, and compare architecture
  77.  *    types and version numbers.  Allocate a process control block,
  78.  *    or match up with an existing shadow copy.
  79.  *
  80.  * Results:
  81.  *    SUCCESS is returned if permission is granted, and the local process
  82.  *        id of the process is returned.
  83.  *    PROC_MIGRATION_REFUSED is returned if the node is not accepting
  84.  *        migrated processes, or there is a version mismatch.
  85.  *    GEN_INVALID_ID is returned if some migrations are allowed but
  86.  *        the user is not permitted to migrate (e.g., only root is
  87.  *         allowed).
  88.  *
  89.  * Side effects:
  90.  *    A process may be allocated.
  91.  *
  92.  *----------------------------------------------------------------------
  93.  */
  94. /*ARGSUSED*/
  95. ReturnStatus
  96. ProcMigAcceptMigration(cmdPtr, procPtr, inBufPtr, outBufPtr)
  97.     ProcMigCmd *cmdPtr;/* contains ID of process on this host,
  98.                    or NIL */
  99.     Proc_ControlBlock *procPtr; /* ptr to process control block, or NIL */
  100.     Proc_MigBuffer *inBufPtr;    /* input buffer */
  101.     Proc_MigBuffer *outBufPtr;    /* output buffer (default is empty) */
  102. {
  103.     ProcMigInitiateCmd *initPtr;
  104.     char machType[32];
  105.     int permMask;
  106.     Proc_PID *pidPtr;
  107.     int clientID;        /* Sprite ID of client host */
  108.  
  109.     if (proc_MigDebugLevel > 5) {
  110.     printf("ProcMigAcceptMigration called.\n");
  111.     }
  112.     if (inBufPtr->size != sizeof(ProcMigInitiateCmd)) {
  113.     /*
  114.      * Implicit version mismatch if they're not the same size.
  115.      */
  116.     if (proc_MigDebugLevel > 0) {
  117.         printf("Migration version mismatch: size of initiation request");
  118.         printf(" is %d, not %d.\n", inBufPtr->size,
  119.                sizeof(ProcMigInitiateCmd));
  120.         }
  121.     return(PROC_MIGRATION_REFUSED);
  122.     }
  123.  
  124.     initPtr = (ProcMigInitiateCmd *) inBufPtr->ptr;
  125.     clientID = initPtr->clientID;
  126.     if (initPtr->version != proc_MigrationVersion) {
  127.     if (proc_MigDebugLevel > 1) {
  128.         printf("Migration version mismatch: we are level %d; client %d is level %d.\n",
  129.            proc_MigrationVersion, clientID, initPtr->version);
  130.     }
  131.     return(PROC_MIGRATION_REFUSED);
  132.     }
  133.     if (cmdPtr->remotePid == (Proc_PID) NIL) {
  134.     /*
  135.      * Do various checks regarding whether we're accepting any migrations,
  136.      * then allocate a process.
  137.      */
  138.     if ((proc_AllowMigrationState & PROC_MIG_IMPORT_ALL) ==
  139.         PROC_MIG_IMPORT_NEVER) {
  140.         if (proc_MigDebugLevel > 4) {
  141.         printf("Warning: Proc_RpcMigInit: migration rejected because we are refusing migrations.\n");
  142.         }
  143.         return(PROC_MIGRATION_REFUSED);
  144.     }
  145.     if (initPtr->userID == PROC_SUPER_USER_ID) {
  146.         permMask = PROC_MIG_IMPORT_ROOT;
  147.     } else {
  148.         permMask = PROC_MIG_IMPORT_ALL;
  149.     }
  150.  
  151.     if ((proc_AllowMigrationState & permMask) != permMask) {
  152.         if (proc_MigDebugLevel > 2) {
  153.         printf("Proc_Migrate: user does not have permission to migrate.\n");
  154.         }
  155.         return(GEN_NO_PERMISSION);
  156.     }
  157.     
  158.     Net_SpriteIDToMachType(clientID, 32, machType);
  159.     if (*machType == '\0') {
  160.         printf("Warning: Proc_RpcMigInit: couldn't get machine type for client %d.\n",
  161.            clientID);
  162.         return(PROC_MIGRATION_REFUSED);
  163.     }
  164.     if (strcmp(machType, mach_MachineType)) {
  165.         if (proc_MigDebugLevel > 0) {
  166.         printf("Warning: Proc_RpcMigInit: client %d (%s) tried to migrate to this machine.\n",
  167.                clientID, machType);
  168.         }
  169.         return(PROC_MIGRATION_REFUSED);
  170.     }
  171.     /*
  172.      * Allocate a new process table entry for the migrating process.
  173.      */
  174.     procPtr = ProcGetUnusedPCB();
  175.     procPtr->peerProcessID = initPtr->processID;
  176.     procPtr->peerHostID = clientID;
  177.     procPtr->state = PROC_NEW;
  178.     procPtr->genFlags |= PROC_FOREIGN;
  179.  
  180.     pidPtr = (Proc_PID *) malloc(sizeof(Proc_PID));
  181.     *pidPtr = procPtr->processID;
  182.     Proc_Unlock(procPtr);
  183.     outBufPtr->ptr = (Address) pidPtr;
  184.     outBufPtr->size = sizeof(Proc_PID);
  185.  
  186.     /*
  187.      * Remember the dependency on the other host.
  188.      */
  189.     ProcMigAddDependency(procPtr->processID, procPtr->peerProcessID);
  190.     } else {
  191.     if (procPtr == (Proc_ControlBlock *) NIL) {
  192.         panic("ProcMigAcceptMigration: given null control block for existing process\n");
  193.         return(PROC_NO_PEER);
  194.     }
  195.     }
  196.     if (proc_MigDebugLevel > 5) {
  197.     printf("ProcMigAcceptMigration returning SUCCESS.\n");
  198.     }
  199.     return(SUCCESS);
  200. }
  201.  
  202.  
  203. /*
  204.  *----------------------------------------------------------------------
  205.  *
  206.  * ProcMigDestroyCmd --
  207.  *
  208.  *    Handle a request to destroy a migrated process, possibly
  209.  *    one that has not completed migration quite yet.
  210.  *
  211.  * Results:
  212.  *    SUCCESS.
  213.  *
  214.  * Side effects:
  215.  *    A process may be allocated.
  216.  *
  217.  *----------------------------------------------------------------------
  218.  */
  219. /*ARGSUSED*/
  220. ReturnStatus
  221. ProcMigDestroyCmd(cmdPtr, procPtr, inBufPtr, outBufPtr)
  222.     ProcMigCmd *cmdPtr;/* contains ID of process on this host */
  223.     Proc_ControlBlock *procPtr; /* ptr to process control block */
  224.     Proc_MigBuffer *inBufPtr;    /* input buffer */
  225.     Proc_MigBuffer *outBufPtr;    /* output buffer (stays empty) */
  226. {
  227.     Proc_DestroyMigratedProc((ClientData) procPtr->processID, 
  228.                 (Proc_CallInfo *) NIL);
  229.     return(SUCCESS);
  230. }
  231.  
  232.  
  233. /*
  234.  *----------------------------------------------------------------------
  235.  *
  236.  * ProcMigContinueProcess --
  237.  *
  238.  *    Restore the state of a migrated process to its state prior to
  239.  *    migration.  If it is migrating home, remove the link between
  240.  *    the foreign copy of the process and this copy.  Add it to the
  241.  *    ready queue.
  242.  *
  243.  *
  244.  * Results:
  245.  *      A ReturnStatus.  (SUCCESS for now.)
  246.  *
  247.  * Side effects:
  248.  *    The process may be made runnable.
  249.  *
  250.  *----------------------------------------------------------------------
  251.  */
  252.  
  253. /*ARGSUSED*/
  254. ReturnStatus
  255. ProcMigContinueProcess(cmdPtr, procPtr, inBufPtr, outBufPtr)
  256.     ProcMigCmd *cmdPtr;/* contains ID of process on this host */
  257.     Proc_ControlBlock *procPtr; /* ptr to process control block */
  258.     Proc_MigBuffer *inBufPtr;    /* input buffer */
  259.     Proc_MigBuffer *outBufPtr;    /* output buffer (stays empty) */
  260. {
  261.     if (proc_MigDebugLevel > 10) {
  262.     printf(">> Entering debugger before continuing process %x.\n", procPtr->processID);
  263.     DBG_CALL;
  264.     }
  265.  
  266.     Proc_Lock(procPtr);
  267.     if (!(procPtr->genFlags & PROC_FOREIGN)) {
  268.     procPtr->peerProcessID = (Proc_PID) NIL;
  269.     procPtr->peerHostID = NIL;
  270.     }
  271.     procPtr->genFlags |= PROC_MIGRATION_DONE;
  272.     Proc_Unlock(procPtr);
  273.     Sched_MakeReady(procPtr);
  274.  
  275.     return(SUCCESS);
  276. }
  277.  
  278.  
  279. /*
  280.  *----------------------------------------------------------------------
  281.  *
  282.  * Proc_ResumeMigProc --
  283.  *
  284.  *    Resume a migrated user process.  This is the first thing that is
  285.  *     called when a migrated process continues execution.
  286.  *    If the process is actually performing a remote exec, then
  287.  *     call the routine to perform the exec, which won't return.
  288.  *
  289.  * Results:
  290.  *    Does not return.
  291.  *
  292.  * Side effects:
  293.  *    None.
  294.  *
  295.  *----------------------------------------------------------------------
  296.  */
  297.  
  298. void
  299. Proc_ResumeMigProc(pc)
  300.     int pc;        /* program counter to resume execution */
  301. {
  302.     register         Proc_ControlBlock *procPtr;
  303.  
  304.  
  305.     MASTER_UNLOCK(sched_MutexPtr);
  306.  
  307.     procPtr = Proc_GetCurrentProc();
  308.     Proc_Lock(procPtr);
  309.     if (procPtr->migFlags & PROC_EVICTING) {
  310.     /*
  311.      * Just to make sure we migrate back home ASAP...
  312.      */
  313.     Sig_SendProc(procPtr, SIG_MIGRATE_HOME, 0, (Address)0);
  314.     }
  315.     if (procPtr->genFlags & PROC_REMOTE_EXEC_PENDING) {
  316.     ProcDoRemoteExec(procPtr);
  317.     /*
  318.      * NOTREACHED
  319.      */
  320.     }
  321.     procPtr->genFlags &= ~PROC_NO_VM;
  322.     VmMach_ReinitContext(procPtr);
  323.     Proc_Unlock(procPtr);
  324.  
  325.     if (procPtr->unixProgress != PROC_PROGRESS_NOT_UNIX &&
  326.         procPtr->unixProgress != PROC_PROGRESS_UNIX) {
  327.     if (debugProcStubs) {
  328.         printf("Unix progress = %d (mig)\n", procPtr->unixProgress);
  329.     }
  330.     }
  331.     if (procPtr->unixProgress == PROC_PROGRESS_MIG_RESTART) {
  332.     if (debugProcStubs) {
  333.         printf("Restarting migrated system call\n");
  334.     }
  335.     procPtr->unixProgress = PROC_PROGRESS_RESTART;
  336.     }
  337.  
  338.     /*
  339.      * Start the process running.  This does not return.  
  340.      */
  341.  
  342.     Mach_StartUserProc(procPtr, (Address) pc);
  343.     panic("Proc_ResumeMigProc: Mach_StartUserProc returned.\n");
  344. }
  345.  
  346.  
  347. /*
  348.  *----------------------------------------------------------------------
  349.  *
  350.  * Proc_DoRemoteCall --
  351.  *
  352.  *    Generic system call handler for migrated processes.  This routine
  353.  *    takes a specification for the system call to invoke and the usage
  354.  *    of its parameters and sends them to the home node for processing.
  355.  *      Each parameter has a type and a disposition.  The type indicates
  356.  *    whether the parameter is an int, string, or other specialized
  357.  *     structure.  The disposition is "in", "out", or "in/out", as well
  358.  *    as whether the parameter should be accessed using Vm_Copy{In,Out}
  359.  *    or Vm_MakeAccessible.  The specific defined constants are documented
  360.  *    in sysSysCallParam.h.
  361.  *
  362.  *    All "in" or "in/out" parameters are sent in the RPC in the data
  363.  *    buffer.  All "out" or "in/out" parameters have space allocated for
  364.  *    them in the reply data buffer.  Strings and characters are padded
  365.  *    so that each field is aligned on an even address, so the actual
  366.  *    addresses within the buffers may be cast as integers and other types
  367.  *    without additional copying.
  368.  *
  369.  * Results:
  370.  *    A ReturnStatus is returned.  Values may be returned in the areas
  371.  *    referenced by pointers that are passed into the routine, but they
  372.  *    are dependent upon the system call invoked.
  373.  *
  374.  * Side effects:
  375.  *    A remote procedure call is performed.  
  376.  *
  377.  *----------------------------------------------------------------------
  378.  */
  379.  
  380. ReturnStatus
  381. Proc_DoRemoteCall(callNumber, numWords, argsPtr, specsPtr)
  382.     int callNumber;            /* number of system call to invoke */
  383.     int numWords;            /* number of words passed in */
  384.     ClientData *argsPtr;        /* pointer to data passed in */
  385.     Sys_CallParam *specsPtr;        /* array of information about the
  386.                      * parameters to this call */
  387. {
  388.     Proc_ControlBlock     *procPtr;    /* The migrated process */
  389.     int dataSize = 0;            /* size of the data buffer */
  390.     int replyDataSize = 0;        /* size of the reply buffer */
  391.     Address ptr;            /* place holder within buffer */
  392.     int *intArgsArray;            /* to treat argsPtr as array of ints */
  393.     int disp;                /* "disposition" of a parameter */
  394.     int type;                /* type of param (int, string, ...) */
  395.     int size;                /* number of bytes of a param */
  396.     int paddedSize;            /* likewise, padded to be aligned */
  397.     Proc_RemoteCall call;        /* parameter information for RPC */
  398.     Address pointerArray[SYS_MAX_ARGS]; /* array of made accessible pointers */
  399.     int numBytesAccessible[SYS_MAX_ARGS];/* number of bytes made accessible,
  400.                       * or zero if this variable has not
  401.                       * been made accessible */
  402.     Rpc_Storage storage;        
  403.     Address dataBuffer = (Address) NIL;
  404.     Address replyDataBuffer = (Address) NIL;
  405.     int i;
  406.     register ReturnStatus status;    /* returned by assorted procedures */
  407.     ReturnStatus remoteCallStatus;    /* status returned by system call */
  408.     Proc_TraceRecord record;        /* used to store trace data */
  409.     int lastArraySize = -1;            /* size of last array found */
  410.     int numTries;            /* number of times trying RPC */
  411.  
  412.     /*
  413.      * Create a synonym for argsPtr so that integer arguments can be referred
  414.      * to without casting them all the time.
  415.      */
  416.     
  417.     intArgsArray = (int *) argsPtr;
  418.     
  419.     
  420.     procPtr = Proc_GetActualProc();
  421.  
  422.     /*
  423.      * Check to make sure the home node is up, and kill the process if
  424.      * it isn't.  The call to exit never returns.
  425.      */
  426.     status = Recov_IsHostDown(procPtr->peerHostID);
  427.     if (status != SUCCESS) {
  428.     if (proc_MigDebugLevel > 0) {
  429.         printf("Proc_DoRemoteCall: host %d is down; killing process %x.\n",
  430.                procPtr->peerHostID, procPtr->processID);
  431.     }
  432.     Proc_ExitInt(PROC_TERM_DESTROYED, (int) PROC_NO_PEER, 0);
  433.     /*
  434.      * This point should not be reached, but the N-O-T-R-E-A-C-H-E-D
  435.      * directive causes a complaint when there's code after it.
  436.      */
  437.     panic("Proc_DoRemoteCall: Proc_ExitInt returned.\n");
  438.     return(PROC_NO_PEER);
  439.     }
  440.  
  441.     /*
  442.      * Set up the RPC parameters: pass the home processID, the system call
  443.      * number, and parameter information.  Additional parameter information
  444.      * (type and disposition) is copied below.
  445.      */
  446.  
  447.     call.processID = procPtr->peerProcessID;
  448.     call.callNumber = callNumber;
  449.     call.numArgs = numWords;
  450.     call.parseArgs = TRUE;
  451.  
  452. #ifndef CLEAN
  453.     if (proc_DoTrace && proc_DoCallTrace) {
  454.     record.processID = call.processID;
  455.     record.flags = PROC_MIGTRACE_START;
  456.     record.info.call.callNumber = callNumber;
  457.     Trace_Insert(proc_TraceHdrPtr, PROC_MIGTRACE_CALL,
  458.              (ClientData) &record);
  459.     }
  460. #endif /* CLEAN */   
  461.  
  462.     for (i = 0; i < numWords; i++) {
  463.     numBytesAccessible[i] = 0;
  464.     }
  465.  
  466.     /*
  467.      * Determine the type and size of each argument.  If the argument is
  468.      * a string, make it accessible now in order to find its size.
  469.      */
  470.  
  471.     for (i = 0; i < numWords; i++) {
  472.     disp = specsPtr[i].disposition;
  473.     type = specsPtr[i].type;
  474.     if ((disp & SYS_PARAM_OUT) &&
  475.         !(disp & (SYS_PARAM_ACC | SYS_PARAM_COPY))) {
  476.         panic("Proc_DoRemoteCall: Illegal parameter information for call %d for output parameter %d",
  477.               callNumber, i);
  478.         return(GEN_INVALID_ARG);
  479.     }
  480.     switch(type) {
  481.         case SYS_PARAM_INT:
  482.         case SYS_PARAM_CHAR: 
  483.         case SYS_PARAM_PROC_PID:
  484.         case SYS_PARAM_PROC_RES:
  485.         case SYS_PARAM_SYNC_LOCK:
  486.         case SYS_PARAM_FS_ATT:
  487.         case SYS_PARAM_TIMEPTR: 
  488.         case SYS_PARAM_TIME1:
  489.         case SYS_PARAM_TIME2:
  490.         case SYS_PARAM_RANGE1:
  491.         case SYS_PARAM_RANGE2:
  492.         case SYS_PARAM_PCB:
  493.         case SYS_PARAM_PCBARG:
  494.         case SYS_PARAM_VM_CMD:
  495.         case SYS_PARAM_DUMMY:
  496.             /*
  497.          * For typical arguments, the size may be found in a global
  498.          * array that is subscripted by the type.  If the argument
  499.          * is really an array, multiply by the number of arguments.
  500.          *
  501.          * Special case Proc_GetPCBInfo because it can allow
  502.          * a range of values or a PROC_MY_PID to specify one
  503.          * value.
  504.          */
  505.             if ((! (disp & SYS_PARAM_ARRAY)) ||
  506.                 (callNumber == SYS_PROC_GETPCBINFO &&
  507.                 intArgsArray[0] == PROC_MY_PID)) {
  508.             size = sys_ParamSizes[type];
  509.         } else {
  510.             /*
  511.              * The argument is actually a pointer to an array of
  512.              * the given type.  The size of the array is either
  513.              * the parameter just before the array pointer (an INT),
  514.              * or the difference between the two preceding arguments
  515.              * (RANGE1 and RANGE2).  Remember the size of the array,
  516.              * since a more arrays of the same size may follow.
  517.              *
  518.              */
  519.             if (i > 0 && specsPtr[i-1].type == SYS_PARAM_INT) {
  520.             size = (intArgsArray[i-1]) *
  521.                 sys_ParamSizes[type];
  522.             } else if (i > 1 && specsPtr[i-2].type ==
  523.                    SYS_PARAM_RANGE1 &&
  524.                    specsPtr[i-1].type == SYS_PARAM_RANGE2) {
  525.              if (type == SYS_PARAM_PCB) {
  526.                 intArgsArray[i-1] = intArgsArray[i-1] &
  527.                     PROC_INDEX_MASK;
  528.                 intArgsArray[i-2] = intArgsArray[i-2]  &
  529.                     PROC_INDEX_MASK;
  530.             }
  531.             size = (intArgsArray[i-1] - intArgsArray[i-2] + 1) *
  532.                 sys_ParamSizes[type];
  533.             } else if (i > 1 && (specsPtr[i-1].disposition
  534.                      & (SYS_PARAM_ARRAY))) {
  535.             size = lastArraySize;
  536.             } else {
  537.             panic("Proc_DoRemoteCall: bad parameter list.\n");
  538.             status = FAILURE;
  539.             goto failure;
  540.             }
  541.             lastArraySize = size;
  542.         }
  543.         break;
  544.          case SYS_PARAM_FS_NAME: 
  545.                 /*
  546.          * The argument is a string.  If copying a string in, make
  547.          * it accessible and figure out its size dynamically.  If
  548.          * copying it out, just allocate space for the maximum number 
  549.          * of bytes for that type.
  550.          */
  551.         if ((disp & SYS_PARAM_ACC) && (disp & SYS_PARAM_IN)) {
  552.             status = Proc_MakeStringAccessible(sys_ParamSizes[type],
  553.                  (char **) &argsPtr[i], &numBytesAccessible[i], &size);
  554.             if (status != SUCCESS) {
  555.             if (proc_MigDebugLevel > 6) {
  556.                 panic("Proc_DoRemoteCall: status %x returned by Proc_MakeStringAccessible.\n", status);
  557.             }
  558.             goto failure;
  559.             }
  560.             /*
  561.               * Send the null byte as well.
  562.              */
  563.             size += 1;
  564.         } else if ((disp & SYS_PARAM_COPY) && (disp & SYS_PARAM_OUT)) {
  565.             size = sys_ParamSizes[type];
  566.         } else {
  567.             panic("Proc_DoRemoteCall: can't handle string parameter combination.\n");
  568.             status = FAILURE;
  569.             goto failure;
  570.         }
  571.         pointerArray[i] = (Address) argsPtr[i];
  572.         break;                    
  573.         default:
  574.         panic("Proc_DoRemoteCall: can't handle argument type.\n");
  575.         status = FAILURE;
  576.         goto failure;
  577.     }
  578.  
  579.     /*
  580.      * Store the information about this parameter.  If the argument is
  581.      * a pointer and it is USER_NIL, then store the fact that the
  582.      * parameter is NIL so that we won't try to copy out to that address
  583.      * later on, or to make it accessible.  Keep track of the sizes of the
  584.      * input and output buffers.  Make accessible anything that isn't
  585.      * already accessible.
  586.      */
  587.     call.info[i].size = size;
  588.     if ((disp & (SYS_PARAM_COPY | SYS_PARAM_ACC))
  589.             && !ValidAddress(argsPtr[i])) {
  590.         disp |= SYS_PARAM_NIL;
  591.     } else {
  592.         paddedSize = Byte_AlignAddr(size);
  593.         if (disp & SYS_PARAM_IN) {
  594.         dataSize += paddedSize;
  595.         }
  596.         if (disp & SYS_PARAM_OUT) {
  597.         replyDataSize += paddedSize;
  598.         }
  599.     }
  600.     call.info[i].disposition = disp;
  601.     if ((disp & SYS_PARAM_ACC) && numBytesAccessible[i] == 0) {
  602.         if (! (disp & SYS_PARAM_NIL)) {
  603.         int accessType; 
  604.  
  605.         if ((disp & SYS_PARAM_IN) && !(disp & SYS_PARAM_OUT)) {
  606.             accessType = VM_READONLY_ACCESS;
  607.         } else if (!(disp & SYS_PARAM_IN) && (disp & SYS_PARAM_OUT)) {
  608.             accessType = VM_OVERWRITE_ACCESS;
  609.         } else {
  610.             accessType = VM_READWRITE_ACCESS;
  611.         }
  612.         Vm_MakeAccessible(accessType, size, (Address) argsPtr[i],
  613.                   &numBytesAccessible[i], &pointerArray[i]);
  614.         if (numBytesAccessible[i] != size ||
  615.                 pointerArray[i] == (Address) NIL) {
  616.             status = SYS_ARG_NOACCESS;
  617.             goto failure;
  618.         }
  619.         } else {
  620.         pointerArray[i] = (Address) NIL;
  621.         }
  622.     }
  623.     }
  624.  
  625.     /*
  626.      * Now that the total sizes are known, allocate space and save the
  627.      * arguments in the data buffer.  While the RPC system and network
  628.      * driver are confused and screw up on buffers that are too small,
  629.      * pad the sizes accordingly.
  630.      */
  631.  
  632. #define RPC_MIN_BUFFER_SIZE 12
  633. #ifdef RPC_MIN_BUFFER_SIZE
  634.     if (dataSize < RPC_MIN_BUFFER_SIZE) {
  635.     dataSize = RPC_MIN_BUFFER_SIZE;
  636.     }
  637.     if (replyDataSize < RPC_MIN_BUFFER_SIZE) {
  638.     replyDataSize = RPC_MIN_BUFFER_SIZE;
  639.     }
  640. #endif /* RPC_MIN_BUFFER_SIZE */
  641.     
  642.     dataBuffer = (Address) malloc(dataSize);
  643.     ptr = dataBuffer;
  644.     replyDataBuffer = (Address) malloc(replyDataSize);
  645.     call.replySize = replyDataSize;
  646.  
  647.     for (i = 0; i < numWords; i++) {
  648.     disp = call.info[i].disposition;
  649.     if ((disp & SYS_PARAM_IN) && ! (disp & SYS_PARAM_NIL)) {
  650.         if (disp & SYS_PARAM_ACC) {
  651.         bcopy(pointerArray[i], ptr, call.info[i].size);
  652.         } else if (disp & SYS_PARAM_COPY) {
  653.         status = Vm_CopyIn(call.info[i].size, (Address) argsPtr[i],
  654.                    ptr);
  655.         if (status != SUCCESS) {
  656.             goto failure;
  657.         }
  658.         } else {
  659.         bcopy((Address) &argsPtr[i], ptr, call.info[i].size);
  660.         }
  661.     ptr += Byte_AlignAddr(call.info[i].size);
  662.     }
  663.     }
  664.  
  665.     /*
  666.      * Set up for the RPC.
  667.      */
  668.     storage.requestParamPtr = (Address) &call;
  669.     storage.requestParamSize = sizeof(Proc_RemoteCall);
  670.  
  671.     storage.requestDataPtr = dataBuffer;
  672.     storage.requestDataSize = dataSize;
  673.  
  674.     storage.replyParamPtr = (Address) NIL;
  675.     storage.replyParamSize = 0;
  676.     storage.replyDataPtr = replyDataBuffer;
  677.     storage.replyDataSize = replyDataSize;
  678.  
  679.     if (proc_MigDebugLevel > 4) {
  680.     printf("Proc_DoRemoteCall: sending call %d home.\n", callNumber); 
  681.     }
  682.  
  683.     for (numTries = 0; numTries < PROC_MAX_RPC_RETRIES; numTries++) {
  684.     remoteCallStatus = Rpc_Call(procPtr->peerHostID, RPC_PROC_REMOTE_CALL,
  685.                     &storage);
  686.     if (remoteCallStatus != RPC_TIMEOUT) {
  687.         break;
  688.     }
  689.     status = Proc_WaitForHost(procPtr->peerHostID);
  690.     if (status != SUCCESS) {
  691.         break;
  692.     }
  693.     }
  694.     if (proc_MigDebugLevel > 4) {
  695.     printf("Proc_DoRemoteCall: status %x returned by Rpc_Call.\n",
  696.            remoteCallStatus);
  697.     }
  698. #ifndef CLEAN
  699.     if (proc_DoTrace && proc_DoCallTrace) {
  700.     record.flags &= ~PROC_MIGTRACE_START;
  701.     record.info.call.status = remoteCallStatus;
  702.     Trace_Insert(proc_TraceHdrPtr, PROC_MIGTRACE_CALL,
  703.              (ClientData) &record);
  704.     }
  705. #endif /* CLEAN */   
  706.  
  707.     /*
  708.      * If we were told the process no longer exists on the home node,
  709.      * then blow it away.
  710.      */
  711.     if (remoteCallStatus == PROC_NO_PEER) {
  712.     status = PROC_NO_PEER;
  713.     (void) Sig_Send(SIG_KILL, (int) PROC_NO_PEER, procPtr->processID,
  714.             FALSE, (Address)0); 
  715.     goto failure;
  716.     }
  717.     /*
  718.      * Step through the reply data buffer and copy out any arguments that
  719.      * were output parameters.
  720.      */
  721.  
  722.     ptr = replyDataBuffer;
  723.     for (i = 0; i < numWords; i++) {
  724.     disp = call.info[i].disposition;
  725.     if (disp & SYS_PARAM_ACC) {
  726.         if ((disp & SYS_PARAM_OUT) && !(disp & SYS_PARAM_NIL)) {
  727.         bcopy(ptr, pointerArray[i], call.info[i].size);
  728.         ptr += Byte_AlignAddr(call.info[i].size);
  729.         }
  730.         if (numBytesAccessible[i] > 0) {
  731.         Vm_MakeUnaccessible(pointerArray[i], numBytesAccessible[i]);
  732.         numBytesAccessible[i] = 0;
  733.         }
  734.     } else if ((disp & SYS_PARAM_COPY) && (disp & SYS_PARAM_OUT)
  735.            && !(disp & SYS_PARAM_NIL)) {
  736.         size = call.info[i].size;
  737.         status = Vm_CopyOut(size, ptr, (Address) argsPtr[i]);
  738.         if (status != SUCCESS) {
  739.         if (proc_MigDebugLevel > 6) {
  740.             panic("Proc_DoRemoteCall: status %x returned by Vm_CopyOut.\n",
  741.                    status);
  742.         }
  743.  
  744.         status = SYS_ARG_NOACCESS;
  745.         goto failure;
  746.         }
  747.         ptr += Byte_AlignAddr(call.info[i].size);
  748.     }
  749.     }
  750.  
  751.     free(dataBuffer);
  752.     free(replyDataBuffer);
  753.     
  754.     return(remoteCallStatus);
  755.  
  756.  
  757.     /*
  758.      * Try to unwind after an error by making everything unaccessible
  759.      * again and freeing memory before returning the error condition.
  760.      * Note: if the procedure has progressed far enough for dataBuffer 
  761.      * to be non_NIL, then replyDataBuffer should be non-NIL then as well.
  762.      */
  763.  
  764. failure:
  765.  
  766.     for (i = 0; i < numWords; i++) {
  767.     if (numBytesAccessible[i] > 0) {
  768.         Vm_MakeUnaccessible(pointerArray[i], numBytesAccessible[i]);
  769.     }
  770.     }
  771.     if (dataBuffer != (Address) NIL) {
  772.     free(dataBuffer);
  773.     free(replyDataBuffer);
  774.     }
  775.     return(status);
  776. }
  777.  
  778.  
  779. /*
  780.  *----------------------------------------------------------------------
  781.  *
  782.  * Proc_RemoteDummy --
  783.  *
  784.  *    Dummy routine to return FAILURE for any system call not yet
  785.  *    implemented.
  786.  *
  787.  * Results:
  788.  *    FAILURE.
  789.  *
  790.  * Side effects:
  791.  *    None.  
  792.  *
  793.  *----------------------------------------------------------------------
  794.  */
  795.  
  796. /* ARGSUSED */
  797. ReturnStatus
  798. Proc_RemoteDummy(callNumber, numWords, argsPtr, specsPtr)
  799.     int callNumber;
  800.     int numWords;
  801.     Sys_ArgArray *argsPtr;
  802.     Sys_CallParam *specsPtr;
  803. {
  804.     printf("Warning: Call %d not yet implemented.\n", callNumber);
  805.     return(FAILURE);
  806. }
  807.  
  808.  
  809. /*
  810.  * ----------------------------------------------------------------------------
  811.  *
  812.  * ProcRemoteFork --
  813.  *
  814.  *    Perform an RPC to execute a fork on behalf of a migrated process.
  815.  *
  816.  * Results:
  817.  *    The status returned by the RPC is returned.
  818.  *
  819.  * Side effects:
  820.  *    An RPC is performed.  A skeletal process is created on the home node
  821.  *    to be the "real" process corresponding to the migrated forked process
  822.  *    that is in the process of being created.  The ID of the child on
  823.  *    the home node is stored in the PCB of the remote process.
  824.  *
  825.  * ----------------------------------------------------------------------------
  826.  */
  827.  
  828. ReturnStatus
  829. ProcRemoteFork(parentProcPtr, childProcPtr)
  830.     Proc_ControlBlock *parentProcPtr;    /* PCB for parent */
  831.     Proc_ControlBlock *childProcPtr;        /* PCB for child */
  832. {
  833.     Rpc_Storage storage;
  834.     Proc_RemoteCall call;
  835.     ReturnStatus status;
  836.     Proc_TraceRecord record;        /* used to store trace data */
  837.     int numTries;            /* number of times trying RPC */
  838.  
  839.     if (proc_MigDebugLevel > 3) {
  840.     printf("ProcRemoteFork called.\n");
  841.     }
  842.  
  843.     status = Recov_IsHostDown(parentProcPtr->peerHostID);
  844.     if (status != SUCCESS) {
  845.     if (proc_MigDebugLevel > 0) {
  846.         printf("ProcRemoteFork: host %d is down; killing process %x.\n",
  847.                parentProcPtr->peerHostID, parentProcPtr->processID);
  848.     }
  849.     Proc_ExitInt(PROC_TERM_DESTROYED, (int) PROC_NO_PEER, 0);
  850.     /*
  851.      * This point should not be reached, but the N-O-T-R-E-A-C-H-E-D
  852.      * directive causes a complaint when there's code after it.
  853.      */
  854.     panic("ProcRemoteFork: Proc_ExitInt returned.\n");
  855.     return(PROC_NO_PEER);
  856.     }
  857.  
  858. #ifndef CLEAN
  859.     if (proc_DoTrace && proc_DoCallTrace) {
  860.     record.processID = parentProcPtr->peerProcessID;
  861.     record.flags = PROC_MIGTRACE_START;
  862.     record.info.call.callNumber = SYS_PROC_FORK;
  863.     Trace_Insert(proc_TraceHdrPtr, PROC_MIGTRACE_CALL,
  864.              (ClientData) &record);
  865.     }
  866. #endif /* CLEAN */   
  867.  
  868.     /*
  869.      * Set up for the RPC.
  870.      */
  871.     call.processID = parentProcPtr->peerProcessID;
  872.     call.callNumber = SYS_PROC_FORK;
  873.     call.parseArgs = FALSE;
  874.     storage.requestParamPtr = (Address) &call;
  875.     storage.requestParamSize = sizeof(Proc_RemoteCall);
  876.  
  877.     storage.requestDataPtr = (Address) &childProcPtr->processID;
  878.     storage.requestDataSize = sizeof(int);
  879.  
  880.     storage.replyParamPtr = (Address) NIL;
  881.     storage.replyParamSize = 0;
  882.     storage.replyDataPtr = (Address) &childProcPtr->peerProcessID;
  883.     storage.replyDataSize = sizeof(Proc_PID);
  884.  
  885.     for (numTries = 0; numTries < PROC_MAX_RPC_RETRIES; numTries++) {
  886.     status = Rpc_Call(parentProcPtr->peerHostID, RPC_PROC_REMOTE_CALL,
  887.                &storage);
  888.     if (status != RPC_TIMEOUT) {
  889.         break;
  890.     }
  891.     status = Proc_WaitForHost(parentProcPtr->peerHostID);
  892.     if (status != SUCCESS) {
  893.         break;
  894.     }
  895.     }
  896.  
  897. #ifndef CLEAN
  898.     if (proc_DoTrace && proc_DoCallTrace) {
  899.     record.flags &= ~PROC_MIGTRACE_START;
  900.     record.info.call.status = status;
  901.     Trace_Insert(proc_TraceHdrPtr, PROC_MIGTRACE_CALL,
  902.              (ClientData) &record);
  903.     }
  904. #endif /* CLEAN */   
  905.  
  906.     /*
  907.      * If we were told the process no longer exists on the home node,
  908.      * then blow it away.  Any other return status just means we didn't
  909.      * initialize the child properly.
  910.      */
  911.     if (status != SUCCESS) {
  912.     if (status == PROC_NO_PEER) {
  913.         (void) Sig_Send(SIG_KILL, (int) PROC_NO_PEER,
  914.                 parentProcPtr->processID, FALSE, (Address)0); 
  915.     }
  916.     if (proc_MigDebugLevel > 0) {
  917.         printf("Warning: ProcRemoteFork returning status %x.\n",
  918.                status);
  919.     }
  920.     return(status);
  921.     }
  922.     childProcPtr->peerHostID = parentProcPtr->peerHostID;
  923.     childProcPtr->genFlags |= PROC_FOREIGN;
  924.     childProcPtr->kcallTable = mach_MigratedHandlers;
  925.  
  926.     /*
  927.      * Note the dependency of the new process on the other host.
  928.      */
  929.     ProcMigAddDependency(childProcPtr->processID, childProcPtr->peerProcessID);
  930.  
  931.     /*
  932.      * Update statistics.
  933.      */
  934.     PROC_MIG_INC_STAT(foreign);
  935.  
  936.     if (proc_MigDebugLevel > 3) {
  937.     printf("ProcRemoteFork returning status %x.\n", status);
  938.     }
  939.     return(status);
  940. }
  941.  
  942.  
  943. /*
  944.  *----------------------------------------------------------------------
  945.  *
  946.  * ProcRemoteExit --
  947.  *
  948.  *    Cause a migrated process to exit.  Throw away its address space, but
  949.  *     migrate runtime information back to the home node.  
  950.  *
  951.  * Results:
  952.  *    None.
  953.  *
  954.  * Side effects:
  955.  *    A remote procedure call is performed and the part of the
  956.  *     process state that survives past Proc_Exit is transferred.
  957.  *
  958.  *----------------------------------------------------------------------
  959.  */
  960.  
  961. void
  962. ProcRemoteExit(procPtr, reason, exitStatus, code)
  963.     register Proc_ControlBlock     *procPtr;  /* process that is exiting */
  964.     int reason;    /* Why the process is dying: EXITED, SIGNALED, DESTROYED  */
  965.     int    exitStatus;    /* Exit status or signal # or destroy status */
  966.     int code;    /* Signal sub-status */
  967. {
  968.     Address buffer;
  969.     Address ptr;
  970.     int bufferSize;
  971.     Rpc_Storage storage;
  972.     Proc_RemoteCall call;
  973.     ReturnStatus status;
  974.     Proc_TraceRecord record;        /* used to store trace data */
  975.     int numTries;            /* number of times trying RPC */
  976.  
  977.     if (proc_MigDebugLevel > 4) {
  978.     printf("ProcRemoteExit(%x) called.\n", exitStatus);
  979.     }
  980.  
  981.     /*
  982.      * Update statistics.
  983.      */
  984.     if (!(procPtr->genFlags & PROC_DONT_MIGRATE)) {
  985.     PROC_MIG_DEC_STAT(foreign);
  986.     } else {
  987.     if (proc_MigDebugLevel > 3) {
  988.         printf("ProcRemoteExit: process %x is foreign but unmigratable.\n",
  989.            procPtr->processID);
  990.     }
  991.     }
  992.     if ((procPtr->migFlags & PROC_EVICTING) ||
  993.     (proc_MigStats.foreign == 0 &&
  994.      proc_MigStats.evictionsInProgress != 0)) {
  995.     ProcMigEvictionComplete();
  996.     }
  997.  
  998.  
  999.     status = Recov_IsHostDown(procPtr->peerHostID);
  1000.     if (status != SUCCESS) {
  1001.     if (proc_MigDebugLevel > 0) {
  1002.         printf("ProcRemoteExit: host %d is down; ignoring exit for process %x.\n",
  1003.                procPtr->peerHostID, procPtr->processID);
  1004.     }
  1005.     /*
  1006.      * Remove the dependency on the other host, but note that the host
  1007.      * is down now.
  1008.      */
  1009.     ProcMigRemoveDependency(procPtr->processID, FALSE);
  1010.     return;
  1011.     }
  1012.  
  1013.     ProcMigRemoveDependency(procPtr->processID, TRUE);
  1014. #ifndef CLEAN
  1015.     if (proc_DoTrace && proc_DoCallTrace) {
  1016.     record.processID = procPtr->processID;
  1017.     record.flags = PROC_MIGTRACE_START;
  1018.     record.info.call.callNumber = SYS_PROC_EXIT;
  1019.     Trace_Insert(proc_TraceHdrPtr, PROC_MIGTRACE_CALL,
  1020.              (ClientData) &record);
  1021.     }
  1022. #endif /* CLEAN */   
  1023.  
  1024.  
  1025.     bufferSize = 2 * sizeof(Timer_Ticks) + 5 * sizeof(int);
  1026.     buffer = (Address) malloc(bufferSize);
  1027.  
  1028.     ptr = buffer;
  1029.     Byte_FillBuffer(ptr, Timer_Ticks,  procPtr->kernelCpuUsage.ticks);
  1030.     Byte_FillBuffer(ptr, Timer_Ticks,  procPtr->userCpuUsage.ticks);
  1031.     Byte_FillBuffer(ptr, int,  procPtr->numQuantumEnds);
  1032.     Byte_FillBuffer(ptr, int,  procPtr->numWaitEvents);
  1033.     Byte_FillBuffer(ptr, int, reason);
  1034.     Byte_FillBuffer(ptr, int, exitStatus);
  1035.     Byte_FillBuffer(ptr, int, code);
  1036.  
  1037.  
  1038.     /*
  1039.      * Set up for the RPC.
  1040.      */
  1041.     call.processID = procPtr->peerProcessID;
  1042.     call.callNumber = SYS_PROC_EXIT;
  1043.     call.parseArgs = FALSE;
  1044.     storage.requestParamPtr = (Address) &call;
  1045.     storage.requestParamSize = sizeof(Proc_RemoteCall);
  1046.  
  1047.     storage.requestDataPtr = buffer;
  1048.     storage.requestDataSize = bufferSize;
  1049.  
  1050.     storage.replyParamPtr = (Address) NIL;
  1051.     storage.replyParamSize = 0;
  1052.     storage.replyDataPtr = (Address) NIL;
  1053.     storage.replyDataSize = 0;
  1054.  
  1055.  
  1056.     for (numTries = 0; numTries < PROC_MAX_RPC_RETRIES; numTries++) {
  1057.     status = Rpc_Call(procPtr->peerHostID, RPC_PROC_REMOTE_CALL, &storage);
  1058.     if (status != RPC_TIMEOUT) {
  1059.         break;
  1060.     }
  1061.     status = Proc_WaitForHost(procPtr->peerHostID);
  1062.     if (status != SUCCESS) {
  1063.         break;
  1064.     }
  1065.     }
  1066.  
  1067. #ifndef CLEAN
  1068.     if (proc_DoTrace && proc_DoCallTrace) {
  1069.     record.flags &= ~PROC_MIGTRACE_START;
  1070.     record.info.call.status = status;
  1071.     Trace_Insert(proc_TraceHdrPtr, PROC_MIGTRACE_CALL,
  1072.              (ClientData) &record);
  1073.     }
  1074. #endif /* CLEAN */   
  1075.  
  1076.     free(buffer);
  1077.  
  1078.     if ((status != SUCCESS) && (proc_MigDebugLevel > 0)) {
  1079.     printf("Warning: ProcRemoteExit received status %x.\n", status);
  1080.     }
  1081. }
  1082.  
  1083.  
  1084. /*
  1085.  *----------------------------------------------------------------------
  1086.  *
  1087.  * ProcRemoteExec --
  1088.  *
  1089.  *    Tell the home node of a process that it has done an exec, and to
  1090.  *     change any information it might have about effective IDs.  
  1091.  *
  1092.  * Results:
  1093.  *    None.
  1094.  *
  1095.  * Side effects:
  1096.  *    A remote procedure call is performed.
  1097.  *
  1098.  *----------------------------------------------------------------------
  1099.  */
  1100.  
  1101. void
  1102. ProcRemoteExec(procPtr, uid)
  1103.     register Proc_ControlBlock     *procPtr;  /* process that is doing exec */
  1104.     int uid;                   /* new effective user ID, or -1 */
  1105. {
  1106.     Address buffer;
  1107.     Address ptr;
  1108.     int bufferSize;
  1109.     Rpc_Storage storage;
  1110.     Proc_RemoteCall call;
  1111.     ReturnStatus status;
  1112.     Proc_TraceRecord record;        /* used to store trace data */
  1113.     int numTries;            /* number of times trying RPC */
  1114.  
  1115.     if (proc_MigDebugLevel > 4) {
  1116.     printf("ProcRemoteExec(%s) called.\n", procPtr->argString);
  1117.     }
  1118.  
  1119.     status = Recov_IsHostDown(procPtr->peerHostID);
  1120.     if (status != SUCCESS) {
  1121.     if (proc_MigDebugLevel > 0) {
  1122.         printf("ProcRemoteExec: host %d is down; killing process %x.\n",
  1123.                procPtr->peerHostID, procPtr->processID);
  1124.     }
  1125.     Proc_Unlock(procPtr);
  1126.     Proc_ExitInt(PROC_TERM_DESTROYED, (int) PROC_NO_PEER, 0);
  1127.     /*
  1128.      * This point should not be reached, but the N-O-T-R-E-A-C-H-E-D
  1129.      * directive causes a complaint when there's code after it.
  1130.      */
  1131.     panic("ProcRemoteExec: Proc_ExitInt returned.\n");
  1132.     return;
  1133.     }
  1134.  
  1135.  
  1136. #ifndef CLEAN
  1137.     if (proc_DoTrace && proc_DoCallTrace) {
  1138.     record.processID = procPtr->processID;
  1139.     record.flags = PROC_MIGTRACE_START;
  1140.     record.info.call.callNumber = SYS_PROC_EXEC;
  1141.     Trace_Insert(proc_TraceHdrPtr, PROC_MIGTRACE_CALL,
  1142.              (ClientData) &record);
  1143.     }
  1144. #endif /* CLEAN */   
  1145.  
  1146.  
  1147.  
  1148.     bufferSize = sizeof(int) + strlen(procPtr->argString) + 1;
  1149.     buffer = (Address) malloc(bufferSize);
  1150.  
  1151.     ptr = buffer;
  1152.     Byte_FillBuffer(ptr, int,  uid);
  1153.     (void) strcpy(ptr,  procPtr->argString);
  1154.  
  1155.  
  1156.     /*
  1157.      * Set up for the RPC.
  1158.      */
  1159.     call.processID = procPtr->peerProcessID;
  1160.     call.callNumber = SYS_PROC_EXEC;
  1161.     call.parseArgs = FALSE;
  1162.     storage.requestParamPtr = (Address) &call;
  1163.     storage.requestParamSize = sizeof(Proc_RemoteCall);
  1164.  
  1165.     storage.requestDataPtr = buffer;
  1166.     storage.requestDataSize = bufferSize;
  1167.  
  1168.     storage.replyParamPtr = (Address) NIL;
  1169.     storage.replyParamSize = 0;
  1170.     storage.replyDataPtr = (Address) NIL;
  1171.     storage.replyDataSize = 0;
  1172.  
  1173.  
  1174.     /*
  1175.      * Unlock the process while we're doing the RPC.
  1176.      */
  1177.     Proc_Unlock(procPtr);
  1178.     
  1179.     for (numTries = 0; numTries < PROC_MAX_RPC_RETRIES; numTries++) {
  1180.     status = Rpc_Call(procPtr->peerHostID, RPC_PROC_REMOTE_CALL, &storage);
  1181.     if (status != RPC_TIMEOUT) {
  1182.         break;
  1183.     }
  1184.     status = Proc_WaitForHost(procPtr->peerHostID);
  1185.     if (status != SUCCESS) {
  1186.         break;
  1187.     }
  1188.     }
  1189.  
  1190.     /*
  1191.      * Give the process back the way it was handed to us (locked).
  1192.      */
  1193.     Proc_Lock(procPtr);
  1194.  
  1195. #ifndef CLEAN
  1196.     if (proc_DoTrace && proc_DoCallTrace) {
  1197.     record.flags &= ~PROC_MIGTRACE_START;
  1198.     record.info.call.status = status;
  1199.     Trace_Insert(proc_TraceHdrPtr, PROC_MIGTRACE_CALL,
  1200.              (ClientData) &record);
  1201.     }
  1202. #endif /* CLEAN */   
  1203.  
  1204.  
  1205.     free(buffer);
  1206.  
  1207.     if ((status != SUCCESS) && (proc_MigDebugLevel > 0)) {
  1208.     printf("Warning: ProcRemoteExec received status %x.\n", status);
  1209.     }
  1210. }
  1211.  
  1212.  
  1213.